home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zdevice2.c < prev    next >
C/C++ Source or Header  |  1997-06-18  |  9KB  |  331 lines
  1. /* Copyright (C) 1993, 1995, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zdevice2.c */
  20. /* Level 2 device operators */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "ghost.h"
  24. #include "errors.h"
  25. #include "oper.h"
  26. #include "dstack.h"            /* for dict_find_name */
  27. #include "estack.h"
  28. #include "idict.h"
  29. #include "idparam.h"
  30. #include "igstate.h"
  31. #include "iname.h"
  32. #include "store.h"
  33. #include "gxdevice.h"
  34. #include "gsstate.h"
  35.  
  36. /* Imported data */
  37. extern op_proc_p zcopy_procs[t_next_index];
  38.  
  39. /* Forward references */
  40. private int z2copy_gstate(P1(os_ptr));
  41. private int near push_callout(P1(const char _ds *));
  42.  
  43. /* Initialize by adding changing the `copy' operator for gstates. */
  44. /* This is a hack -- we know that gstates are the only */
  45. /* t_astruct subtype that implements copy. */
  46. private void
  47. zdevice2_init(void)
  48. {    zcopy_procs[t_astruct] = z2copy_gstate;
  49. }
  50.  
  51. /* - .currentshowpagecount <count> true */
  52. /* - .currentshowpagecount false */
  53. private int
  54. zcurrentshowpagecount(register os_ptr op)
  55. {    gx_device *dev = gs_currentdevice(igs);
  56.  
  57.     if ( (*dev_proc(dev, get_page_device))(dev) == 0 )
  58.       {    push(1);
  59.         make_false(op);
  60.       }
  61.     else
  62.       {    push(2);
  63.         make_int(op - 1, dev->ShowpageCount);
  64.         make_true(op);
  65.       }
  66.     return 0;
  67. }
  68.  
  69. /* - .currentpagedevice <dict> <bool> */
  70. private int
  71. zcurrentpagedevice(register os_ptr op)
  72. {    gx_device *dev = gs_currentdevice(igs);
  73.  
  74.     push(2);
  75.     if ( (*dev_proc(dev, get_page_device))(dev) != 0 )
  76.       { op[-1] = istate->pagedevice;
  77.         make_true(op);
  78.       }
  79.     else
  80.       { op[-1] = i_null_pagedevice;
  81.         make_false(op);
  82.       }
  83.     return 0;
  84. }
  85.  
  86. /* <dict> .setpagedevice - */
  87. private int
  88. zsetpagedevice(register os_ptr op)
  89. {    int code;
  90.  
  91. /******
  92.     if ( igs->in_cachedevice )
  93.       return_error(e_undefined);
  94.  ******/
  95.     check_type(*op, t_dictionary);
  96.     check_dict_read(*op);
  97.     /* Make the dictionary read-only. */
  98.     code = zreadonly(op);
  99.     if ( code < 0 )
  100.       return code;
  101.     istate->pagedevice = *op;
  102.     pop(1);
  103.     return 0;
  104. }
  105.  
  106. /* Default Install/BeginPage/EndPage procedures */
  107. /* that just call the procedure in the device. */
  108.  
  109. /* - .callinstall - */
  110. private int
  111. zcallinstall(os_ptr op)
  112. {    gx_device *dev = gs_currentdevice(igs);
  113.  
  114.     if ( (dev = (*dev_proc(dev, get_page_device))(dev)) != 0 )
  115.       {    int code = (*dev->page_procs.install)(dev, igs);
  116.         if ( code < 0 )
  117.           return code;
  118.       }
  119.     return 0;
  120. }
  121.  
  122. /* <showpage_count> .callbeginpage - */
  123. private int
  124. zcallbeginpage(os_ptr op)
  125. {    gx_device *dev = gs_currentdevice(igs);
  126.  
  127.     check_type(*op, t_integer);
  128.     if ( (dev = (*dev_proc(dev, get_page_device))(dev)) != 0 )
  129.       {    int code = (*dev->page_procs.begin_page)(dev, igs);
  130.         if ( code < 0 )
  131.           return code;
  132.       }
  133.     pop(1);
  134.     return 0;
  135. }
  136.  
  137. /* <showpage_count> <reason_int> .callendpage <flush_bool> */
  138. private int
  139. zcallendpage(os_ptr op)
  140. {    gx_device *dev = gs_currentdevice(igs);
  141.     int code;
  142.  
  143.     check_type(op[-1], t_integer);
  144.     check_type(*op, t_integer);
  145.     if ( (dev = (*dev_proc(dev, get_page_device))(dev)) != 0 )
  146.       {    code = (*dev->page_procs.end_page)(dev, (int)op->value.intval, igs);
  147.         if ( code < 0 )
  148.           return code;
  149.         if ( code > 1 )
  150.           return_error(e_rangecheck);
  151.       }
  152.     else
  153.       {    code = (op->value.intval == 2 ? 0 : 1);
  154.       }
  155.     make_bool(op - 1, code);
  156.     pop(1);
  157.     return 0;
  158. }
  159.  
  160. /* ------ Wrappers for operators that save the graphics state. ------ */
  161.  
  162. /* When saving the state with the current device a page device, */
  163. /* we need to make sure that the page device dictionary exists */
  164. /* so that grestore can use it to reset the device parameters. */
  165. /* This may have significant performance consequences, but we don't see */
  166. /* any way around it. */
  167.  
  168. /* Check whether we need to call out to create the page device dictionary. */
  169. #define save_page_device(pgs)\
  170.   (gs_int_gstate(pgs)->pagedevice.value.pdict ==\
  171.      i_null_pagedevice.value.pdict &&\
  172.    (*dev_proc(gs_currentdevice(pgs), get_page_device))(gs_currentdevice(pgs))\
  173.      != 0)
  174.    
  175. /* - gsave - */
  176. private int
  177. z2gsave(os_ptr op)
  178. {    if ( !save_page_device(igs) )
  179.       return gs_gsave(igs);
  180.     return push_callout("%gsavepagedevice");
  181. }
  182.    
  183. /* - save - */
  184. private int
  185. z2save(os_ptr op)
  186. {    if ( !save_page_device(igs) )
  187.       return zsave(op);
  188.     return push_callout("%savepagedevice");
  189. }
  190.  
  191. /* - gstate <gstate> */
  192. private int
  193. z2gstate(os_ptr op)
  194. {    if ( !save_page_device(igs) )
  195.       return zgstate(op);
  196.     return push_callout("%gstatepagedevice");
  197. }
  198.  
  199. /* <gstate1> <gstate2> copy <gstate2> */
  200. private int
  201. z2copy_gstate(os_ptr op)
  202. {    if ( !save_page_device(igs) )
  203.       return zcopy_gstate(op);
  204.     return push_callout("%copygstatepagedevice");
  205. }
  206.  
  207. /* <gstate1> <gstate2> currentgstate <gstate2> */
  208. private int
  209. z2currentgstate(os_ptr op)
  210. {    if ( !save_page_device(igs) )
  211.       return zcurrentgstate(op);
  212.     return push_callout("%currentgstatepagedevice");
  213. }
  214.  
  215. /* ------ Wrappers for operators that reset the graphics state. ------ */
  216.  
  217. /* Check whether we need to call out to restore the page device. */
  218. private bool near
  219. restore_page_device(const gs_state *pgs_old, const gs_state *pgs_new)
  220. {    gx_device *dev_old = gs_currentdevice(pgs_old);
  221.     gx_device *dev_new;
  222.     gx_device *dev_t1;
  223.     gx_device *dev_t2;
  224.  
  225.     if ( (dev_t1 = (*dev_proc(dev_old, get_page_device))(dev_old)) == 0 )
  226.       return false;
  227.     dev_new = gs_currentdevice(pgs_new);
  228.     if ( dev_old != dev_new )
  229.       { if ( (dev_t2 = (*dev_proc(dev_new, get_page_device))(dev_new)) == 0 )
  230.           return false;
  231.         if ( dev_t1 != dev_t2 )
  232.           return true;
  233.       }
  234.     /* The current implementation of setpagedevice just sets new */
  235.     /* parameters in the same device object, so we have to check */
  236.     /* whether the page device dictionaries are the same. */
  237.     { const ref *pdict1 = &gs_int_gstate(pgs_old)->pagedevice;
  238.       const ref *pdict2 = &gs_int_gstate(pgs_new)->pagedevice;
  239.       return pdict1->value.pdict != pdict2->value.pdict;
  240.     }
  241. }
  242.  
  243. /* - grestore - */
  244. private int
  245. z2grestore(os_ptr op)
  246. {    if ( !restore_page_device(igs, gs_state_saved(igs)) )
  247.       return gs_grestore(igs);
  248.     return push_callout("%grestorepagedevice");
  249. }
  250.  
  251. /* - grestoreall - */
  252. private int
  253. z2grestoreall(os_ptr op)
  254. {    for ( ; ; )
  255.       { if ( !restore_page_device(igs, gs_state_saved(igs)) )
  256.           { bool done = !gs_state_saved(gs_state_saved(igs));
  257.  
  258.             gs_grestore(igs);
  259.         if ( done )
  260.           break;
  261.           }
  262.         else
  263.           return push_callout("%grestoreallpagedevice");
  264.       }
  265.     return 0;
  266. }
  267.  
  268. /* <save> restore - */
  269. private int
  270. z2restore(os_ptr op)
  271. {    for ( ; ; )
  272.     {    if ( !restore_page_device(igs, gs_state_saved(igs)) )
  273.         {    zgrestore(op);
  274.             if ( !gs_state_saved(gs_state_saved(igs)) )
  275.               break;
  276.         }
  277.         else
  278.           return push_callout("%restorepagedevice");
  279.     }
  280.     return zrestore(op);
  281. }
  282.  
  283. /* <gstate> setgstate - */
  284. private int
  285. z2setgstate(os_ptr op)
  286. {    check_stype(*op, st_igstate_obj);
  287.     if ( !restore_page_device(igs, igstate_ptr(op)) )
  288.       return zsetgstate(op);
  289.     return push_callout("%setgstatepagedevice");
  290. }
  291.  
  292. /* ------ Initialization procedure ------ */
  293.  
  294. BEGIN_OP_DEFS(zdevice2_l2_op_defs) {
  295.         op_def_begin_level2(),
  296.     {"0.currentshowpagecount", zcurrentshowpagecount},
  297.     {"0.currentpagedevice", zcurrentpagedevice},
  298.     {"1.setpagedevice", zsetpagedevice},
  299.         /* Note that the following replace prior definitions */
  300.         /* in the indicated files: */
  301.     {"0gsave", z2gsave},            /* zgstate.c */
  302.     {"0save", z2save},            /* zvmem.c */
  303.     {"0gstate", z2gstate},            /* zdps1.c */
  304.     {"1currentgstate", z2currentgstate},    /* zdps1.c */
  305.     {"0grestore", z2grestore},        /* zgstate.c */
  306.     {"0grestoreall", z2grestoreall},    /* zgstate.c */
  307.     {"1restore", z2restore},        /* zvmem.c */
  308.     {"1setgstate", z2setgstate},        /* zdps1.c */
  309.         /* Default Install/BeginPage/EndPage procedures */
  310.         /* that just call the procedure in the device. */
  311.     {"0.callinstall", zcallinstall},
  312.     {"1.callbeginpage", zcallbeginpage},
  313.     {"2.callendpage", zcallendpage},
  314. END_OP_DEFS(zdevice2_init) }
  315.  
  316. /* ------ Internal routines ------ */
  317.  
  318. /* Call out to a PostScript procedure. */
  319. private int near
  320. push_callout(const char _ds *callout_name)
  321. {    int code;
  322.  
  323.     check_estack(1);
  324.     code = name_enter_string(callout_name, esp + 1);
  325.     if ( code < 0 )
  326.       return code;
  327.     ++esp;
  328.     r_set_attrs(esp, a_executable);
  329.     return o_push_estack;
  330. }
  331.